home *** CD-ROM | disk | FTP | other *** search
/ PD ROM 1 / PD ROM Volume I - Macintosh Software from BMUG (1988).iso / Programming / Programming Tools / HFS Find. / HFS Finder -C < prev   
Encoding:
Text File  |  1994-10-02  |  18.7 KB  |  646 lines  |  [TEXT/ttxt]
  1.  
  2. #include <acc.h>
  3. #include <file.h>
  4. #include <os.h>
  5. #include <win.h>
  6. #include <qdvars.h>
  7. #include <event.h>
  8. #include <te.h>
  9. #include <dialog.h>
  10. #include <control.h>
  11. #include <device.h>
  12. #include <desk.h>
  13.  
  14. ACC( 0x0400, 0, 0xfffb, 0, 9, "HFS Find " )
  15.  
  16. #define     MAXLEVEL    32    /* how deep we can go */
  17.  
  18. DialogPtr dp;                 /* modeless dialog for string selection */
  19. DialogPtr rp;                 /* modal dialog for search results */
  20. cinfopbrec  mycpb;            /* for cat info */
  21. wdpbrec     mywdpb;           /* for vref of default volume */
  22.  
  23. OSErr err;
  24. char  name[MAXLEVEL][32];           /* names of path components */
  25.  
  26. int   modkeys;                /* state of modifier keys at last event */
  27. int   OurRef;                 /* our reference number */
  28. unsigned int   resbase;       /* our first resource */ 
  29.  
  30. accopen( dctl, pb )
  31.       dctlentry *dctl;
  32.       paramblockrec *pb;
  33. {
  34.       if ( dctl->dCtlWindow == 0 )
  35.       {
  36.             GrafPtr saveport;
  37.             
  38.             GetPort(&saveport);
  39.             OurRef = dctl->dCtlRefNum;
  40.             resbase = (unsigned)0xc000 | (-32 * ( 1 + OurRef ));
  41.             dp = GetNewDialog( resbase, 0L, -1L );
  42.             ((WindowPeek)dp)->windowKind = OurRef;
  43.             rp = GetNewDialog( resbase+1, 0L, -1L );
  44.             ((WindowPeek)rp)->windowKind = OurRef;
  45.             dctl->dCtlWindow = (WindowPeek)dp;
  46.             /* activate NAME box and select SEARCH WHOLE DISK */
  47.             press(2); press(16);
  48.             SetPort(saveport);
  49.         }
  50. }
  51.  
  52. accclose( dctl, pb )
  53.       dctlentry *dctl;
  54.       paramblockrec *pb;
  55. {
  56.       DisposDialog( rp );
  57.       DisposDialog( dp );
  58.       dctl->dCtlWindow = 0;
  59.       return 0;
  60. }
  61.  
  62. accctl( dctl, pb )
  63.       dctlentry *dctl;
  64.       paramblockrec *pb;
  65. {
  66.       EventRecord *erp;
  67.       GrafPtr savedport;
  68.       DialogPtr whatDialog;
  69.       int whatItem, tf;
  70.       
  71.       GetPort( &savedport );
  72.       
  73.       switch ( pb->paramunion.CntrlParam.CSCode ) {
  74.             EventRecord event;
  75.       case accCursor:         /* make null event so that insert can flash */
  76.             event.what = 0;
  77.             DialogSelect( &event, &whatDialog, &whatItem );
  78.             break;
  79.       case accEvent:
  80.             /*
  81.              * Megamax forgot to define the long we need in the paramunion.
  82.              * Rather than add if myself, I just use diskBuff, which is
  83.              * also a long.
  84.              */
  85.             erp = (EventRecord *)(pb->paramunion.CntrlParam.csParam.diskBuff);
  86.             modkeys = erp->modifiers;
  87.             ((WindowPeek)dp)->windowKind = dialogKind;
  88.             if ( IsDialogEvent( erp ) ) {
  89.                   tf = DialogSelect( erp, &whatDialog, &whatItem );
  90.                   if ( tf && whatDialog == dp ) {
  91.                         SetPort( dp );
  92.                         press( whatItem );
  93.                   }
  94.             }
  95.             ((WindowPeek)dp)->windowKind = OurRef;
  96.                             break;
  97.       case accCut:
  98.             DlgCut( dp ); break;
  99.       case accCopy:
  100.             DlgCopy( dp ); break;
  101.       case accPaste:
  102.             DlgPaste( dp ); break;
  103.       case accClear:
  104.             dlgdelete( dp ); break;
  105.       }
  106.       SetPort( savedport );
  107. }
  108.  
  109. accprime() {}
  110. accstatus() {}
  111.  
  112.  
  113. /*********************************************************************
  114.  ***************** respond to activity in dialog *********************
  115.  *********************************************************************/
  116. press( i )
  117. {
  118.       int type;
  119.       ControlHandle item;
  120.       Rect r;
  121.       
  122.       if ( i == 1 ) {                     /* SEARCH button? */
  123.             dosearch(); return;
  124.       }
  125.       GetDItem( dp, i, &type, &item, &r );
  126.       if ( type == ChkCtrl + CtrlItem ) { /* check box ? */
  127.             type = GetCtlValue( item );
  128.             SetCtlValue( item, 1-type );
  129.             return;
  130.       }
  131.       if ( 12 <= i && i <= 15 ) {         /* type, creator, or a date ? */
  132.             if ( modkeys & 0x100 ) {      /* pretzel key pressed */
  133.                   fromfile( i );
  134.             }
  135.             return;
  136.       }
  137.       if ( i == 17 ) {                    /* CHDIR button ? */
  138.             paramblkptr pb, askfile();
  139.             if ( (pb = askfile()) == 0 )
  140.                   return;
  141.             PBSetVol( pb, FALSE );
  142.             return;
  143.       }
  144. }
  145.  
  146. fromfile( item )
  147. {
  148.       paramblkptr pb, askfile();
  149.       ControlHandle checkbox, editrecord;
  150.       Rect r; int type;
  151.       char buf[12], *cp;
  152.       unsigned long ftime;
  153.       char digit();
  154.       datetimerec dtr;
  155.       
  156.       pb = askfile();
  157.       if ( pb == 0 )
  158.             return;
  159.       switch ( item ) {
  160.       case 14:
  161.             cp = & pb->paramunion.FileParam.ioFlFndrInfo.fdCreator[0];
  162.             goto ct;
  163.       case 15:
  164.             cp = & pb->paramunion.FileParam.ioFlFndrInfo.fdType[0];
  165.       ct:
  166.             buf[0] = *cp++; buf[1] = *cp++;
  167.             buf[2] = *cp++; buf[3] = *cp++;
  168.             buf[4] = 0; break;
  169.       case 12:
  170.       case 13:
  171.             ftime = pb->paramunion.FileParam.ioFlMdDat;
  172.             Secs2Date( ftime, &dtr );
  173.             buf[0] = digit( dtr.month / 10 );
  174.             buf[1] = digit( dtr.month );
  175.             buf[2] = '/';
  176.             buf[3] = digit( dtr.day / 10 );
  177.             buf[4] = digit( dtr.day );
  178.             buf[5] = '/'; 
  179.             buf[6] = digit( dtr.year / 1000 );
  180.             buf[7] = digit( dtr.year / 100 );
  181.             buf[8] = digit( dtr.year / 10 );
  182.             buf[9] = digit( dtr.year );
  183.             buf[10] = 0;
  184.             break;
  185.       }
  186.       GetDItem( dp, item, &type, &editrecord, &r );
  187.       SetIText( editrecord, buf );
  188.       SelIText( dp, item, 0, 0 );
  189.  
  190.       DrawDialog( dp );
  191. }
  192.  
  193. char digit( num )
  194.       int num;
  195. {
  196.       return num % 10 + '0';
  197. }
  198.  
  199. /*********************************************************************
  200.  ****************************** search! ******************************
  201.  *********************************************************************/
  202.  
  203. int   targets[3][50];         /* file name patterns to search for */
  204. int   tN;                     /* true if there are some file names */
  205. long  tType;                  /* type to search for */
  206. long  tCreat;                 /* creator to search for */
  207. int   tT, tC;                 /* true if search for type, creator */
  208. unsigned long  tBefore, tAfter;     /* before and after mod times */
  209. int   tB, tA;                 /* true if search for before, after */
  210.  
  211. char scratchText[40];
  212. dosearch() {
  213.       ControlHandle checkbox, editrecord;
  214.       Rect r; int type, i;
  215.       unsigned long maketime();
  216.       
  217.       tN = 0;
  218.       for ( i = 2; i <= 4; i++ ) {
  219.             GetDItem( dp, i, &type, &checkbox, &r );
  220.             if ( GetCtlValue( checkbox ) ) {
  221.                   GetDItem( dp, i+7, &type, &editrecord, &r );
  222.                   GetIText( editrecord, scratchText );
  223.                   compile( targets[i-2], scratchText );
  224.                   tN++;
  225.             } else
  226.                   targets[i-2][0] = -10;
  227.       }
  228.       /*
  229.        * get target type and creator
  230.        */
  231.       tT = tC = 0;
  232.       GetDItem( dp, 8, &type, &checkbox, &r );
  233.       tT = GetCtlValue( checkbox );
  234.       if ( tT ) {
  235.             GetDItem( dp, 15, &type, &editrecord, &r );
  236.             GetIText( editrecord, scratchText );
  237.             tType = *(long *)scratchText;
  238.       }
  239.       GetDItem( dp, 7, &type, &checkbox, &r );
  240.       tC = GetCtlValue( checkbox );
  241.       if ( tC ) {
  242.             GetDItem( dp, 14, &type, &editrecord, &r );
  243.             GetIText( editrecord, scratchText );
  244.             tCreat = *(long *)scratchText;
  245.       }
  246.       /*
  247.        * mod time before and after
  248.        */
  249.       GetDItem( dp, 5, &type, &checkbox, &r );
  250.       tA = GetCtlValue( checkbox );
  251.       if ( tA ) {
  252.             GetDItem( dp, 12, &type, &editrecord, &r );
  253.             GetIText( editrecord, scratchText );
  254.             tAfter = maketime( scratchText );
  255.       }
  256.       GetDItem( dp, 6, &type, &checkbox, &r );
  257.       tB = GetCtlValue( checkbox );
  258.       if ( tB ) {
  259.             GetDItem( dp, 13, &type, &editrecord, &r );
  260.             GetIText( editrecord, scratchText );
  261.             tBefore = maketime( scratchText );
  262.       }
  263.       /*
  264.        * see if user want to search whole disk, and do search
  265.        */
  266.       GetDItem( dp, 16, &type, &checkbox, &r );
  267.       SearchFiles( GetCtlValue( checkbox ) );
  268. }
  269.  
  270. int AbortSearch;
  271. long eDirID[MAXLEVEL+1];
  272. int curdepth;
  273. char Volume[32];
  274. int toodeep;
  275.       
  276. SearchFiles( fromroot )
  277. {
  278.       AbortSearch = toodeep = 0;
  279.       mywdpb.ioNamePtr = Volume;
  280.       pbhgetvol( &mywdpb, FALSE );
  281.       mycpb.ioCompletion = 0;
  282.       mycpb.ioVRefNum = mywdpb.ioVRefNum;
  283.       curdepth = 0;
  284.       eDirID[0] = fromroot ? 2L : mywdpb.iowddirid;
  285.       if ( !fromroot ) 
  286.             Volume[0] = 0;
  287.       EnumerateCat();
  288.       HideWindow( rp ); SelectWindow( dp );
  289. }
  290.  
  291. long eIndex[MAXLEVEL];
  292.  
  293. EnumerateCat()
  294. {
  295. callSelf:
  296.       CheckAbort();
  297.       if ( curdepth >= MAXLEVEL ) {
  298.             if ( toodeep == 0 ) {
  299.                   NoteAlert( resbase+2, 0L );
  300.                   toodeep = 1;
  301.             }
  302.             goto retHere;
  303.       }
  304.       
  305.       if ( AbortSearch ) {
  306.             if ( AbortSearch == 2 )
  307.                   AbortSearch = 0;
  308.             if ( curdepth == 0 )
  309.                   return;
  310.             else
  311.                   goto retHere;
  312.       }
  313.       
  314.       eIndex[curdepth] = 1;
  315.       do {
  316.             mycpb.ioNamePtr = name[curdepth]; name[curdepth][0] = 0;
  317.             mycpb.ioFDirIndex = eIndex[curdepth];
  318.             mycpb.paramunion.dirinfo.iodrdirid = eDirID[curdepth];
  319.             
  320.             err = pbgetcatinfo(&mycpb,FALSE);
  321. #define FINF      paramunion.hfileinfo.ioFlFndrInfo
  322. #define TYPE      FINF.fdType
  323. #define CREAT     FINF.fdCreator
  324. #define MTIME     paramunion.hfileinfo.ioFlMdDat
  325. #define lType(x)  (*(long *)&(x.TYPE))
  326. #define lCreat(x) (*(long *)&(x.CREAT))
  327. #define lTime(x)  ((unsigned long )(x.MTIME))
  328.             if ( err == 0 ) {
  329.                   if (
  330.                         (!tN || (  matches( targets[0], name[curdepth] )
  331.                                 || matches( targets[1], name[curdepth] )
  332.                                 || matches( targets[2], name[curdepth] )
  333.                                 )
  334.                         )
  335.                   &&
  336.                         (!tT || tType == lType(mycpb))
  337.                   &&
  338.                         (!tC || tCreat == lCreat(mycpb))
  339.                   &&
  340.                         (!tA || tAfter <= lTime(mycpb))
  341.                   &&
  342.                         (!tB || tBefore >= lTime(mycpb))
  343.                   )  
  344.                         dumppath( curdepth, (int)mycpb.ioFlAttrib,
  345.                                eDirID[curdepth] );
  346.                   if ( mycpb.ioFlAttrib & 0x10 ) {
  347.                         eDirID[++curdepth] = 
  348.                               mycpb.paramunion.dirinfo.iodrdirid; 
  349.                         goto callSelf;
  350. retHere:
  351.                         --curdepth;
  352.                         err = 0;
  353.                   }
  354.                   eIndex[curdepth]++;
  355.             }
  356.       } while ( err == 0 && !AbortSearch );
  357.       if ( AbortSearch == 2 )
  358.             AbortSearch = 0;
  359.       if ( curdepth == 0 )
  360.             return;
  361.       else
  362.             goto retHere;
  363. }
  364.  
  365. char path[ 1200 ];                  /* make big enough to hold a full path
  366.                                      * spec for the longest path */
  367. dumppath( level, last, DirID )
  368.       long DirID;
  369. {
  370.       int i; char *pp, *sap();
  371.  
  372.       pp = path; *pp = 0;
  373.       if ( Volume[0] ) {
  374.             pp = sap( pp, Volume ); pp = sap( pp, ":" );
  375.       } else
  376.       if ( level || (last & 0x10) )
  377.             pp = sap( pp, ":" );
  378.       for ( i = 0; i <= level; i++ ) {
  379.             pp = sap( pp, name[i] );
  380.             pp = sap( pp, i == level ? "" : ":" );
  381.       }
  382.       sap( name[level], name[level] );
  383.       ParamText( name[level], path, (last & 0x10) ? "Dir":"File", "" );
  384.       ShowWindow( rp );
  385.       SelectWindow( rp ); DrawDialog( rp );
  386.       SetPort( rp );
  387.       
  388.       while ( 1 ) {
  389.             ((WindowPeek)rp)->windowKind = dialogKind;
  390.             ModalDialog( 0L, &i );
  391.             ((WindowPeek)rp)->windowKind = OurRef;
  392.             switch ( i ) {
  393.             case 2:
  394.                   AbortSearch = 1;  /* FALL THROUGH */
  395.             case 1:
  396.                   return; break;
  397.             case 3:
  398.                   *(long *)0x398 = DirID; break;
  399.             case 6:
  400.                    AbortSearch = 2; return;
  401.             }
  402.       }
  403. }
  404.  
  405. char * sap( str, new )
  406.       register char * str, * new;
  407. {
  408.       while ( *str++ = *new++ )
  409.             ;
  410.       return --str;
  411. }
  412.  
  413. CheckAbort() {
  414.       if ( Button() )
  415.             AbortSearch = 1;
  416. }
  417.  
  418. /*********************************************************************
  419.  ***************** file name matching with wildcards *****************
  420.  *********************************************************************/
  421.  
  422. #define     STAR        -1          /* match zero or more of anything */
  423. #define     QM          -2          /* match one of anything */
  424. #define     END         -3          /* match end of name */
  425.  
  426. #define     QUOTE       ':'         /* turn off special next character */
  427. #define     cSTAR       '*'         /* character for STAR */
  428. #define     cQM         '?'         /* character for QM */
  429. #define     cEND        '$'         /* character for END */
  430.  
  431. compile( dest, src )
  432.       register int * dest;
  433.       register char * src;
  434. {
  435.       register char cc;
  436.       
  437.       while ( 1 ) {
  438.             switch ( cc = *src++ ) {
  439.             case cSTAR:
  440.                   *dest++ = STAR; break;
  441.             case cQM:
  442.                   *dest++ = QM; break;
  443.             case cEND:
  444.                   *dest++ = (*src == '\0') ? END : cc; break;
  445.             case '\0':
  446.                   *dest++ = cc; return; break;
  447.             case QUOTE:
  448.                   if ( (*dest++ = *src++) == '\0' )
  449.                         return;
  450.                   break;
  451.             default:
  452.                   if ( 'A' <= cc && cc <= 'Z' )
  453.                         cc += 'a' - 'A';
  454.                   *dest++ = cc;
  455.             }
  456.       }
  457. }
  458.  
  459. matches( cp, np )
  460.       register  int * cp;           /* the compiled pattern to match */
  461.       register unsigned char * np;  /* the file name to check out */
  462. {
  463.       unsigned char * savenp;
  464.       int * startcp;
  465.       
  466.       savenp = np;
  467.       startcp = cp;
  468.       
  469.       while ( 1 ) {
  470.             char nc;
  471.             if ( *cp == STAR ) {
  472.                   savenp = np;            /* so we can backtrack */
  473.                   while ( *cp == STAR )
  474.                         cp++;
  475.             }
  476.             if ( *cp == '\0' )
  477.                   return 1;
  478.             if ( (nc = *np++) == '\0' )
  479.                   return (*cp == END) ? 1 : 0;
  480.             if ( 'A' <= nc && nc <= 'Z' )
  481.                   nc += 'a' - 'A';
  482.             if ( *cp++ == nc || cp[-1] == QM )
  483.                        continue;
  484.             /*
  485.              * failed to match, so we have to backtrack
  486.              */
  487.             np = savenp + 1;
  488.             while ( *--cp != STAR )
  489.                   if ( cp == startcp )
  490.                         return 0;
  491.       }
  492. }
  493.  
  494. /*********************************************************************
  495.  ******************** Interface to SFGetFile *************************
  496.  *********************************************************************/
  497.       
  498. #include <pack.h>
  499. #include <event.h>
  500.  
  501. SFReply rep;
  502. Point   corner;
  503.  
  504. /*
  505.  * whatfile gets a ref ( V or WD ) num and a name for a user selected file
  506.  */
  507. whatfile( ref, name )
  508.       int *ref;                         /* where to put reference number */
  509.       char *name;                       /* where to put name */
  510. {
  511.       boolean myfilter();
  512.  
  513.       SetPt( &corner, 70, 70 );                         /* where to put the box/
  514.       ShowCursor();                                             /* make sure us/
  515.       rep.good = 1;
  516.       SFGetFile( &corner, (char *)0, (int (*)())0, -1, "",
  517.             (char *)0, &rep );
  518.       if ( !rep.good )
  519.             return -1;
  520.       strcpy( name, rep.fName );    /* copy back name */
  521.       *ref = rep.vRefNum;           /* ...and refNum */
  522.       return 0;                                                                /
  523. }
  524.  
  525. /*
  526.  * askfile returns a paramblkptr for a user selected file
  527.  */ 
  528. paramblkptr askfile() {
  529.       int ref, err;
  530.       static paramblockrec pb;
  531.       
  532.       if ( whatfile( &ref, path ) )
  533.             return (char *)0;
  534.  
  535.       pb.ioCompletion = 0;
  536.       pb.ioNamePtr = path;
  537.       pb.ioVRefNum = ref;
  538.       pb.paramunion.FileParam.ioFVersNum = 0;
  539.       
  540.       err = PBGetFInfo( &pb, FALSE );
  541.       if ( err )
  542.             return (char *)0;
  543.       return &pb;
  544. }
  545.  
  546. /*********************************************************************
  547.  *************************** date conversion *************************
  548.  *********************************************************************/
  549.  
  550. char * getnum( cp, where )
  551.       register char *cp;
  552.       register unsigned long *where;
  553. {
  554.       for ( *where = 0; '0' <= *cp && *cp <= '9'; cp++ )
  555.             *where = *where * 10 + *cp - '0';
  556.       return cp;
  557. }
  558.  
  559. /*
  560.  * convert string to a time in seconds since Jan 1 1904.
  561.  */
  562. unsigned long maketime( cp )
  563.       register char *cp;
  564. {
  565.       long ans;
  566.       register char *tp;
  567.       
  568.       if ( *cp == '-' ) {
  569.             unsigned long relative();
  570.             return relative( ++cp );
  571.       }
  572.       
  573.       for ( tp = cp; *tp; tp++ ) {
  574.             unsigned long absdate();
  575.             if ( *tp == '/' )
  576.                   return absdate( cp );
  577.       }
  578.       
  579.       getnum( cp, &ans );      
  580.       return ans;
  581. }
  582.  
  583. /*
  584.  * Relative to now: nnD for nn days in past, nnH or nnM for
  585.  * hours or minutes
  586.  */
  587. unsigned long
  588. relative( cp )
  589.       register char *cp;
  590. {
  591.       long scale; long interval;
  592.       
  593.       cp = getnum( cp, &interval );
  594.       switch ( *cp ) {
  595.       default: case 'd': case 'D':  scale = 86400; break;
  596.       case 'h': case 'H':           scale = 3600; break;
  597.       case 'm': case 'M':           scale = 60; break;
  598.       }
  599.       return *(unsigned long *)0x20c - scale * interval;
  600. }
  601.  
  602. /*
  603.  * date is MM/DD/YY or MM/DD/YYYY
  604.  */
  605. unsigned long absdate( cp )
  606.       register char *cp;
  607. {
  608.       unsigned long month = 0, day = 0, year = 0;
  609.       datetimerec dtr; unsigned long secs;
  610.       
  611.       cp = getnum( cp, &month );
  612.       if ( *cp++ != '/' )
  613.             return 0L;
  614.       cp = getnum( cp, &day );
  615.       if ( *cp++ != '/' )
  616.             return 0L;
  617.       cp = getnum( cp, &year );
  618.       if ( month < 1 || month > 12 )
  619.             return 0L;
  620.       if ( year < 1900 )
  621.             year += 1900;
  622.       dtr.year = year;
  623.       dtr.month = month;
  624.       dtr.day = day;
  625.       dtr.hour = dtr.minute = dtr.second = 0;
  626.       Date2Secs( &dtr, &secs );
  627.       return secs;
  628. }
  629.  
  630. /*********************************************************************
  631.  ********************** print debugging info *************************
  632.  *********************************************************************/
  633.  
  634. #ifdef APRINT
  635. #define     STOPALERT   12346 /* alert for errors */
  636.  
  637. aprintf( fmt, a1, a2, a3, a4, a5, a6 )
  638.       char *fmt;
  639. {
  640.       char buf[200];
  641.       sprintf( buf, fmt, a1, a2, a3, a4, a5, a6 );
  642.       ParamText( buf, "", "", "" );
  643.       StopAlert( STOPALERT, 0L );
  644. }
  645. #endif
  646.